package com.aliyun;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.aliyun.green20220302.Client;
import com.aliyun.green20220302.models.*;
import com.aliyun.teaopenapi.models.Config;
import com.aliyun.teautil.models.RuntimeOptions;
import com.motu.vertx.module.utility.toolset.Tool;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 阿里云文字检测接口（目前用的sdk代码是文本审核增强版PLUS服务）
 */
public class TextAutoRoute {

    private static final Logger logger = LoggerFactory.getLogger("TextAutoRoute");

    // 预先充值才能使用的账号（检测名称用，取名和导量差不多，比较好预估）
    private static final String key_check_name = "LTAI5tHHN2JT7QysN5jViywq";
    private static final String secret_check_name = "C1uuv4mTe3DFac22UyzjvuJUdCrTVj";

    // 先使用后付费的账户（检测文字用，例如聊天，聊天不好预估数量，所以先使用后付费）
    private static final String key_check_word = "LTAI4FdXvB5oEiKhv7V2Fhjs";
    private static final String secret_check_word = "gCePJ9XdCV38OrdSPCQxnqmqm4o5sv";

    /**
     * 取名和聊天分开，因为单个账号的QPS是有限制，所以分开聊天就不会影响到取名
     * 有导量时可以对取名的账号临时提高QPS数量
     */
    private static Client client_check_name;// 检测名称连接对象
    private static Client client_check_word;// 检测文字连接对象

    // 该类（包含继承类）第一次被调用时执行静态块方法，先执行静态块方法，再执行调用方法
    static {

        // 初始化检测名称连接对象
        Config config = new Config();
        config.setAccessKeyId(key_check_name);
        config.setAccessKeySecret(secret_check_name);
        //接入区域和地址请根据实际情况修改
        config.setRegionId("cn-shanghai");
        config.setEndpoint("green-cip.cn-shanghai.aliyuncs.com");
        //连接时超时时间，单位毫秒（ms）。
        config.setReadTimeout(6000);
        //读取时超时时间，单位毫秒（ms）。
        config.setConnectTimeout(3000);
        // 注意，此处实例化的client请尽可能重复使用，避免重复建立连接，提升检测性能
        try {
            client_check_name = new Client(config);
            logger.info("TextAutoRoute init client_check_name success AccessKeyId:{} AccessKeySecret:{}", key_check_name, secret_check_name);
//            System.out.println("TextAutoRoute init client_check_name success AccessKeyId:"+key_check_name+" AccessKeySecret:{}"+secret_check_name);
        }catch (Exception e){
            logger.error("TextAutoRoute init client_check_name error Exception:{}", Tool.getException(e));
        }

        // 初始化检测文字连接对象
        config = new Config();
        config.setAccessKeyId(key_check_word);
        config.setAccessKeySecret(secret_check_word);
        //接入区域和地址请根据实际情况修改
        config.setRegionId("cn-shanghai");
        config.setEndpoint("green-cip.cn-shanghai.aliyuncs.com");
        //连接时超时时间，单位毫秒（ms）。
        config.setReadTimeout(6000);
        //读取时超时时间，单位毫秒（ms）。
        config.setConnectTimeout(3000);
        // 注意，此处实例化的client请尽可能重复使用，避免重复建立连接，提升检测性能
        try {
            client_check_word = new Client(config);
            logger.info("TextAutoRoute init client_check_word success AccessKeyId:{} AccessKeySecret:{}", key_check_word, secret_check_word);
//            System.out.println("TextAutoRoute init client_check_word success AccessKeyId:"+key_check_word+" AccessKeySecret:{}"+secret_check_word);
        }catch (Exception e){
            logger.error("TextAutoRoute init client_check_word error Exception:{}", Tool.getException(e));
        }
    }

    /**
     * 检测名称（只针对取名检测使用，取名比较关键，所以单独一个方法）
     */
    public static TextCheckResult checkName(String content) {
        return check(content, client_check_name);
    }

    /**
     * 检测文字（除了取名之外的文字检测，例如聊天等）
     */
    public static TextCheckResult checkWord(String content) {
        return check(content, client_check_word);
    }

    /**
     * 文字检测
     */
    private static TextCheckResult check(String content, Client client) {
        if (Tool.isEmpty(content)){
            return new TextCheckResult(false);
        }

        //检测参数构造
        JSONObject serviceParameters = new JSONObject();
        serviceParameters.put("content", content);

		TextModerationPlusRequest textModerationPlusRequest = new TextModerationPlusRequest();
        /*
        文本检测服务 service code
        */
		textModerationPlusRequest.setService("comment_detection_pro");// comment_detection的检测效果会更强，比默认的nickname_detection检测效果号
		textModerationPlusRequest.setServiceParameters(serviceParameters.toJSONString());
        try {
            // 调用方法获取检测结果。
			TextModerationPlusResponse response = client.textModerationPlus(textModerationPlusRequest);

            // 返回检测结果。
            if (response != null) {
                if (response.getStatusCode() == 200) {
					TextModerationPlusResponseBody result = response.getBody();
                    Integer code = result.getCode();
                    if (code != null && code == 200) {
						TextModerationPlusResponseBody.TextModerationPlusResponseBodyData data = result.getData();
                        if (data.getRiskLevel().equalsIgnoreCase("none")){// 验证通过
                            return new TextCheckResult(true);
                        } else{
//							System.out.println("TextModerationPlus check result:" + JSON.toJSONString(result));
                            logger.info("TextModerationPlus check fail content:{} result:{}", content, JSON.toJSONString(result));
                            return new TextCheckResult(false);
                        }
                    } else {
                        logger.error("TextModerationPlus check error text moderation not success. code:{}", code);
                    }
                } else {
                    logger.error("TextModerationPlus check error response not success. status:{}", response.getStatusCode());
                }
            }
        } catch (Exception e) {
            logger.error("TextModerationPlus check error exception:{}", Tool.getException(e));
        }
        return new TextCheckResult(true);// 如果是检测服务器异常，那么本次检测也通过，不会影响到游戏业务
    }

    /**
     * 切换到北京地区检测点
     */
    public static void changeToBeiJingRegion(){
        changeRegion("cn-beijing", "green-cip.cn-beijing.aliyuncs.com");
    }

    /**
     * 切换到深圳地区检测点
     */
    public static void changeToShenZhenRegion(){
        changeRegion("cn-shenzhen", "green-cip.cn-shenzhen.aliyuncs.com");
    }

    /**
     * 切换到上海地区检测点
     */
    public static void changeToShangHaiRegion(){
        changeRegion("cn-shanghai", "green-cip.cn-shanghai.aliyuncs.com");
    }

    private static void changeRegion(String regionId, String endpoint){
        // 初始化检测名称连接对象
        Config config = new Config();
        config.setAccessKeyId(key_check_name);
        config.setAccessKeySecret(secret_check_name);
        //接入区域和地址请根据实际情况修改
        config.setRegionId(regionId);
        config.setEndpoint(endpoint);
        //连接时超时时间，单位毫秒（ms）。
        config.setReadTimeout(6000);
        //读取时超时时间，单位毫秒（ms）。
        config.setConnectTimeout(3000);
        // 注意，此处实例化的client请尽可能重复使用，避免重复建立连接，提升检测性能
        try {
            client_check_name = new Client(config);
            logger.info("TextAutoRoute changeRegion client_check_name success regionId:{} endpoint:{} AccessKeyId:{} AccessKeySecret:{}", regionId, endpoint, key_check_name, secret_check_name);
//            System.out.println("TextAutoRoute changeRegion client_check_name success regionId:"+regionId+" endpoint:"+endpoint+" AccessKeyId:"+key_check_name+" AccessKeySecret:"+secret_check_name);
        }catch (Exception e){
            logger.error("TextAutoRoute changeRegion client_check_name error Exception:{}", Tool.getException(e));
        }

        // 初始化检测文字连接对象
        config = new Config();
        config.setAccessKeyId(key_check_word);
        config.setAccessKeySecret(secret_check_word);
        //接入区域和地址请根据实际情况修改
        config.setRegionId(regionId);
        config.setEndpoint(endpoint);
        //连接时超时时间，单位毫秒（ms）。
        config.setReadTimeout(6000);
        //读取时超时时间，单位毫秒（ms）。
        config.setConnectTimeout(3000);
        // 注意，此处实例化的client请尽可能重复使用，避免重复建立连接，提升检测性能
        try {
            client_check_word = new Client(config);
            logger.info("TextAutoRoute changeRegion client_check_word success regionId:{} endpoint:{} AccessKeyId:{} AccessKeySecret:{}", regionId, endpoint, key_check_word, secret_check_word);
//            System.out.println("TextAutoRoute changeRegion client_check_word success regionId:"+regionId+" endpoint:"+endpoint+" AccessKeyId:"+key_check_word+" AccessKeySecret:"+secret_check_word);
        }catch (Exception e){
            logger.error("TextAutoRoute changeRegion client_check_word error Exception:{}", Tool.getException(e));
        }
    }


    public static void main(String[] args) throws Exception {

        // 创建RuntimeObject实例并设置运行参数。
        RuntimeOptions runtime = new RuntimeOptions();
        runtime.readTimeout = 10000;
        runtime.connectTimeout = 10000;

        //检测参数构造
        JSONObject serviceParameters = new JSONObject();
        serviceParameters.put("content", "蔡其昌");
//        serviceParameters.put("content", "习*大*大");
//        serviceParameters.put("content", "习大大");
//        serviceParameters.put("content", "洗*禁*屏");
//        serviceParameters.put("content", "刁*劲*瓶");
//        serviceParameters.put("content", "家我扣扣：123456");
//        serviceParameters.put("content", "猫则东");
        System.out.println(serviceParameters.toJSONString());

        if (serviceParameters.get("content") == null || serviceParameters.getString("content").trim().length() == 0) {
            System.out.println("text moderation content is empty");
            return;
        }

        TextModerationRequest textModerationRequest = new TextModerationRequest();
        /*
        文本检测服务 service code
        */
        textModerationRequest.setService("comment_detection");
        textModerationRequest.setServiceParameters(serviceParameters.toJSONString());
        try {
            // 调用方法获取检测结果。
            TextModerationResponse response = client_check_word.textModerationWithOptions(textModerationRequest, runtime);

            // 自动路由。
//            if (response != null) {
//                // 服务端错误，区域切换到cn-beijing。
//                if (500 == response.getStatusCode() || (response.getBody() != null && 500 == (response.getBody().getCode()))) {
//                    // 接入区域和地址请根据实际情况修改。
//                    config.setRegionId("cn-beijing");
//                    config.setEndpoint("green-cip.cn-beijing.aliyuncs.com");
//                    client = new Client(config);
//                    response = client.textModerationWithOptions(textModerationRequest, runtime);
//                }
//
//            }
            // 打印检测结果。
            if (response != null) {
                if (response.getStatusCode() == 200) {
                    TextModerationResponseBody result = response.getBody();
                    System.out.println(JSON.toJSONString(result));
                    Integer code = result.getCode();
                    if (code != null && code == 200) {
                        TextModerationResponseBody.TextModerationResponseBodyData data = result.getData();
                        System.out.println("labels = [" + data.getLabels() + "]");
                        System.out.println("reason = [" + data.getReason() + "]");
                    } else {
                        System.out.println("text moderation not success. code:" + code);
                    }
                } else {
                    System.out.println("response not success. status:" + response.getStatusCode());
                }
            }

            // 切换地区
            changeToShenZhenRegion();
            TextCheckResult result = checkWord("蔡其昌");
            System.out.println(result.isPass());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}